import { CenoInterceptor } from "../core/interceptor";
import { Input, Options } from "./options";
import { CenoPromise } from "./promise";

export type CenoInstance = {
    /**
      获取给定的 `url`
      
      @param url - `Request` 对象， `URL` 对象， 或者 URL 字符串。
      @returns 一个添加 `Body` 方法的 `Promise`。
     */
    <T>(url: Input, options?: Options): CenoPromise<T>

    /**
     GET 请求 - 使用选项 `{method: 'get'}` 获取给定的 `url` 。

     @param url - `Request` 对象， `URL` 对象， 或者 URL 字符串。
     @returns 一个添加 `Body` 方法的 `Promise`。
     */
    get: <T>(url: Input, options?: Options) => CenoPromise<T>

    /**
     POST 请求 - 使用选项 `{method: 'post'}` 发送给定的 `url` 。

     @param url - `Request` 对象， `URL` 对象， 或者 URL 字符串。
     @returns 一个添加 `Body` 方法的 `Promise`。
     */
    post: <T>(url: Input, options?: Options) => CenoPromise<T>

    /**
     PUT 请求 - 使用选项 `{method: 'put'}` 发送给定的 `url` 。

     @param url - `Request` 对象， `URL` 对象， 或者 URL 字符串。
     @returns 一个添加 `Body` 方法的 `Promise`。
     */
    put: <T>(url: Input, options?: Options) => CenoPromise<T>

    /**
     DELETE 请求 - 使用选项 `{method: 'delete'}` 发送给定的 `url` 。

     @param url - `Request` 对象， `URL` 对象， 或者 URL 字符串。
     @returns 一个添加 `Body` 方法的 `Promise`。
     */
    delete: <T>(url: Input, options?: Options) => CenoPromise<T>

    /**
     PATCH 请求 - 使用选项 `{method: 'patch'}` 发送给定的 `url` 。

     @param url - `Request` 对象， `URL` 对象， 或者 URL 字符串。
     @returns 一个添加 `Body` 方法的 `Promise`。
     */
    patch: <T>(url: Input, options?: Options) => CenoPromise<T>

    /**
     HEAD 请求 - 使用选项 `{method: 'head'}` 发送给定的 `url` 。

     @param url - `Request` 对象， `URL` 对象， 或者 URL 字符串。
     @returns 一个添加 `Body` 方法的 `Promise`。
     */
    head: (url: Input, options?: Options) => CenoPromise

    /**
     使用全新的默认配置创建一个新的 Ceno 实例。

     @returns 一个新的 Ceno 实例。
     */
    create: (defaultOptions?: Options) => CenoInstance

    /**
     创建一个新的 Ceno 实例，使用你自己的设置覆盖一些默认值。

     与 `ceno.create()` 不同， `ceno.extend()` 从其父级继承默认值。
     
     可以通过向 `.extend()` 提供一个函数来引用父级默认值。

     @example
     ```
     import ceno from 'ceno';

     const api = ceno.create({prefixUrl: 'https//example.com/api'});

     const authApi = api.extend({prefixUrl: `${options.prefixUrl}/auth`});

     const response = await authApi.get('/login');
     //=> 'https://example.com/api/auth/login'

     const response = await api.get('/users');
     //=> 'https://example.com/api/users'
     ```
     
     @returns 一个新的 Ceno 实例。
     */
    extend: (defaultOptions?: Options | ((parentOptions: Options) => Options)) => CenoInstance

    /**
     实例级拦截器管理器。

     可以用来注册请求和响应拦截器，这些拦截器都会应用到该实例的所有请求上。

     @example
     ```
     import ceno from 'ceno';

     const api = ceno.create({
        prefixUrl: 'https://example.com/api'
     });

     api.interceptors.use({
         request: {
             onFulfilled: (request) => {
                 request.headers.set('Authorization', 'Bearer token');
                 return request;
             }
         },
         response: {
             onFulfilled: (response) => {
                 console.log('Response received:', response.status);
                 return response;
             }
         }
     });
     ```
     */
    interceptors: CenoInterceptor
}